variable string origToonName

function xmlPrep()
{
	LavishSettings[ezvg]:Clear
  LavishSettings[Timers]:Clear
  LavishSettings[LootList]:Clear
  LavishSettings[HarvestList]:Clear
  MainUI:Clear
  DetrUI:Clear
  BeneUI:Clear
  FolUI:Clear
  HuntUI:Clear
  PetUI:Clear
  ClassUI:Clear
  Timers:Clear
  
  
  LavishSettings:AddSet[ezvg]
  LavishSettings:AddSet[AbilDict]
  LavishSettings:AddSet[MobDict]
  LavishSettings:AddSet[EffectDict]
  LavishSettings:AddSet[ItemsDict]
  LavishSettings:AddSet[Timers]
  LavishSettings:AddSet[LootList]
  LavishSettings:AddSet[HarvestList]
  LavishSettings[ezvg]:AddSet[MAIN]
  LavishSettings[ezvg]:AddSet[DETR]
  LavishSettings[ezvg]:AddSet[BENE]
  LavishSettings[ezvg]:AddSet[FOL]
  LavishSettings[ezvg]:AddSet[HUNT]
  LavishSettings[ezvg]:AddSet[PET]
  LavishSettings[ezvg]:AddSet[CLASS]
  LavishSettings[ezvg]:AddSet[meleeDebuffRot]
  LavishSettings[ezvg]:AddSet[meleeRot]
  LavishSettings[ezvg]:AddSet[meleeDotRot]
  LavishSettings[ezvg]:AddSet[rangeDebuffRot]
  LavishSettings[ezvg]:AddSet[rangeRot]
  LavishSettings[ezvg]:AddSet[rangeDotRot]
  LavishSettings[ezvg]:AddSet[reactRot]
  LavishSettings[ezvg]:AddSet[debuffRot]
  LavishSettings[ezvg]:AddSet[dotRot]
  LavishSettings[ezvg]:AddSet[nukeRot]
  LavishSettings[ezvg]:AddSet[AERot]
  LavishSettings[ezvg]:AddSet[pullRot]
  LavishSettings[ezvg]:AddSet[noGCDList]
  LavishSettings[ezvg]:AddSet[healBigRot]
  LavishSettings[ezvg]:AddSet[healMedRot]
  LavishSettings[ezvg]:AddSet[healEmgRot]
  LavishSettings[ezvg]:AddSet[healGrpRot]
  LavishSettings[ezvg]:AddSet[healHotRot]
  LavishSettings[ezvg]:AddSet[buffRot]
  LavishSettings[ezvg]:AddSet[combatBuffRot]
  LavishSettings[ezvg]:AddSet[groupBuffRot]
  LavishSettings[ezvg]:AddSet[canniRot]
  LavishSettings[ezvg]:AddSet[burnBuffRot]
  LavishSettings[ezvg]:AddSet[burnRot]
  LavishSettings[ezvg]:AddSet[evasiveRot]
  LavishSettings[ezvg]:AddSet[rescueRot]
  LavishSettings[ezvg]:AddSet[specPtsRot]
  LavishSettings[ezvg]:AddSet[itemBuffRot]
  LavishSettings[ezvg]:AddSet[burnItemBuffRot]
  LavishSettings[ezvg]:AddSet[burnConsumableItemBuffRot]
  LavishSettings[ezvg]:AddSet[invTrash]
  LavishSettings[ezvg]:AddSet[lootOnly]
  LavishSettings[ezvg]:AddSet[itemTankRot]
  LavishSettings[ezvg]:AddSet[itemAssistRot]
  LavishSettings[ezvg]:AddSet[itemOTgtRot]
  LavishSettings[ezvg]:AddSet[itemCanniRot]
  LavishSettings[ezvg]:AddSet[WeaponSets]
  LavishSettings[ezvg]:AddSet[hateToTankRot]
  LavishSettings[ezvg]:AddSet[AEHateToTankRot]
  LavishSettings[ezvg]:AddSet[DTgtDeaggroRot]

  LavishSettings[ezvg]:Import[${LavishScript.CurrentDirectory}/Scripts/ezvg/UI/${Me.FName}.xml]

  LavishSettings[AbilDict]:Import[${LavishScript.CurrentDirectory}/Scripts/ezvg/LIBRARY/abilities.xml]
  
  LavishSettings[MobDict]:Import[${LavishScript.CurrentDirectory}/Scripts/ezvg/LIBRARY/mobs.xml]

  LavishSettings[ItemsDict]:Import[${LavishScript.CurrentDirectory}/Scripts/ezvg/LIBRARY/items.xml]

  call xmlLoad
}

function xmlLoad()
{
  echo --- xmlLoad --- loading settings
  MainUI:Set[${LavishSettings[ezvg].FindSet[MAIN]}]
  DetrUI:Set[${LavishSettings[ezvg].FindSet[DETR]}]
  BeneUI:Set[${LavishSettings[ezvg].FindSet[BENE]}]
  FolUI:Set[${LavishSettings[ezvg].FindSet[FOL]}]
  HuntUI:Set[${LavishSettings[ezvg].FindSet[HUNT]}]
  PetUI:Set[${LavishSettings[ezvg].FindSet[PET]}]
  ClassUI:Set[${LavishSettings[ezvg].FindSet[CLASS]}]
  ;###################
  ;########## MAIN TAB
  ;###################
  Assist:Set[${MainUI.FindSetting[Assist]}]
  Tank:Set[${MainUI.FindSetting[Tank]}]
  Position:Set[${MainUI.FindSetting[Position]}]
  FollowT:Set[${MainUI.FindSetting[FollowT]}]
  doAssist:Set[${MainUI.FindSetting[doAssist, FALSE]}]
  doDeleteTrash:Set[${MainUI.FindSetting[doDeleteTrash, FALSE]}]
  doHeal:Set[${MainUI.FindSetting[doHeal, FALSE]}]
  doFace:Set[${MainUI.FindSetting[doFace, FALSE]}]
  doLoot:Set[${MainUI.FindSetting[doLoot, FALSE]}]
  doLootOnly:Set[${MainUI.FindSetting[doLootOnly, FALSE]}]
  scanLootRng:Set[${MainUI.FindSetting[scanLootRng, 0]}]
  doHarvest:Set[${MainUI.FindSetting[doHarvest, FALSE]}]
  doFollow:Set[${MainUI.FindSetting[doFollow, FALSE]}]
  doMoveToTarget:Set[${FolUI.FindSetting[doMoveToTarget, FALSE]}]
  doCombatFollow:Set[${FolUI.FindSetting[doCombatFollow, FALSE]}]
  doIgnoreFurious:Set[${MainUI.FindSetting[doIgnoreFurious, FALSE]}]
  FollowDist:Set[${FolUI.FindSetting[FollowDist, FALSE]}]
  combatFollowDist:Set[${FolUI.FindSetting[combatFollowDist, FALSE]}]
  moveToTargetDist:Set[${FolUI.FindSetting[moveToTargetDist, 4]}]
  minDist:Set[${FolUI.FindSetting[minDist, 1]}]
  doPositionFront:Set[${MainUI.FindSetting[doPositionFront, FALSE]}]
  doPositionBack:Set[${MainUI.FindSetting[doPositionBack, FALSE]}]
  doPositionSide:Set[${MainUI.FindSetting[doPositionSide, FALSE]}]
  ;###################
  ;########## OPTIONS TAB
  ;###################
  ;========== DETR TAB
  doMeleeDebuff:Set[${DetrUI.FindSetting[doMeleeDebuff, FALSE]}]
  doMelee:Set[${DetrUI.FindSetting[doMelee, FALSE]}]
  doMeleeDots:Set[${DetrUI.FindSetting[doMeleeDots, FALSE]}]
  doRangeDebuff:Set[${DetrUI.FindSetting[doRangeDebuff, FALSE]}]
  doRange:Set[${DetrUI.FindSetting[doRange, FALSE]}]
  doRangeDots:Set[${DetrUI.FindSetting[doRangeDots, FALSE]}]
  doDebuff:Set[${DetrUI.FindSetting[doDebuff, FALSE]}]
  doNuke:Set[${DetrUI.FindSetting[doNuke, FALSE]}]
  doDots:Set[${DetrUI.FindSetting[doDots, FALSE]}]
  doReact:Set[${DetrUI.FindSetting[doReact, FALSE]}]
  doKillingBlow:Set[${DetrUI.FindSetting[doKillingBlow, FALSE]}]
  doAE:Set[${DetrUI.FindSetting[doAE, FALSE]}]
  AEDist:Set[${DetrUI.FindSetting[AEDist, 10]}]
  doEvasive:Set[${DetrUI.FindSetting[doEvasive, FALSE]}]
  doRescue:Set[${DetrUI.FindSetting[doRescue, FALSE]}]
  EngagePct:Set[${DetrUI.FindSetting[EngagePct, 97]}]
  evasivePct:Set[${DetrUI.FindSetting[evasivePct, 20]}]
  enerNukePct:Set[${DetrUI.FindSetting[enerNukePct, 20]}]
  enerDOTPct:Set[${DetrUI.FindSetting[enerDOTPct, 7]}]
  killingBlowPct:Set[${DetrUI.FindSetting[killingBlowPct, 15]}]
  killingBlow:Set[${DetrUI.FindSetting[killingBlow, ""]}]
  ;========== HEAL TAB
  doHOT:Set[${BeneUI.FindSetting[doHOT, FALSE]}]
  doRez:Set[${BeneUI.FindSetting[doRez, FALSE]}]
  nonCombatRez:Set[${BeneUI.FindSetting[nonCombatRez, ""]}]
  doCmbtRez:Set[${BeneUI.FindSetting[doCmbtRez, FALSE]}]
  combatRez:Set[${BeneUI.FindSetting[combatRez, ""]}]
  doGroupHeal:Set[${BeneUI.FindSetting[doGroupHeal, FALSE]}]
  healGrpMinInRng:Set[${BeneUI.FindSetting[healGrpMinInRng, 2]}]
  healBigPct:Set[${BeneUI.FindSetting[healBigPct, 70]}]
  healMedPct:Set[${BeneUI.FindSetting[healMedPct, 50]}]
  healEmgPct:Set[${BeneUI.FindSetting[healEmgPct, 25]}]
  healHOTPct:Set[${BeneUI.FindSetting[healHOTPct, 80]}]
  healGrpPct:Set[${BeneUI.FindSetting[healGrpPct, 80]}]
  rezStone:Set[${BeneUI.FindSetting[rezStone, ""]}]
  ;========== BENE TAB
  doSelfBuff:Set[${BeneUI.FindSetting[doSelfBuff, FALSE]}]
  doCombatBuff:Set[${BeneUI.FindSetting[doCombatBuff, FALSE]}]
  doGroupBuff:Set[${BeneUI.FindSetting[doGroupBuff, FALSE]}]
  doCanni:Set[${BeneUI.FindSetting[doCanni, FALSE]}]
  canniEnerPct:Set[${BeneUI.FindSetting[canniEnerPct, 75]}]
  canniHPPct:Set[${BeneUI.FindSetting[canniHPPct, 20]}]
  ;========== BURN TAB
  doBurn:Set[${DetrUI.FindSetting[doBurn, FALSE]}]
  doBurnItemBuff:Set[${DetrUI.FindSetting[doBurnItemBuff, FALSE]}]
  doBurnConsumableItemBuff:Set[${DetrUI.FindSetting[doBurnConsumableItemBuff, FALSE]}]
  burnPct:Set[${DetrUI.FindSetting[burnPct, 95]}]
  burnAbovePct:Set[${DetrUI.FindSetting[burnAbovePct, 30]}]
  burnTrigger:Set[${DetrUI.FindSetting[burnTrigger]}]
  burnBuffTrigger:Set[${DetrUI.FindSetting[burnBuffTrigger]}]
  doBurnAbil:Set[${DetrUI.FindSetting[doBurnAbil, FALSE]}]
  doBurnBuff:Set[${DetrUI.FindSetting[doBurnBuff, FALSE]}]
  doBurnBuffExists:Set[${DetrUI.FindSetting[doBurnBuffExists, FALSE]}]
  burnBuffExistsTrigger:Set[${DetrUI.FindSetting[burnBuffExistsTrigger]}]
  doBurnEpic:Set[${DetrUI.FindSetting[doBurnEpic, FALSE]}]
  burnEpicName:Set[${DetrUI.FindSetting[burnEpicName]}]
  epicSlot:Set[${DetrUI.FindSetting[epicSlot]}]
  ;========== STANCE TAB
  doMeleeStance:Set[${DetrUI.FindSetting[doMeleeStance, FALSE]}]
  doSpellStance:Set[${DetrUI.FindSetting[doSpellStance, FALSE]}]
  doHealStance:Set[${DetrUI.FindSetting[doHealStance, FALSE]}]
  doEvasiveStance:Set[${DetrUI.FindSetting[doEvasiveStance, FALSE]}]
  doTankStance:Set[${DetrUI.FindSetting[doTankStance, FALSE]}]
  doBurnStance:Set[${DetrUI.FindSetting[doBurnStance, FALSE]}]
  doCanniStance:Set[${DetrUI.FindSetting[doCanniStance, FALSE]}]
  meleeStance:Set[${DetrUI.FindSetting[meleeStance, ""]}]
  spellStance:Set[${DetrUI.FindSetting[spellStance, ""]}]
  healStance:Set[${DetrUI.FindSetting[healStance, ""]}]
  evasiveStance:Set[${DetrUI.FindSetting[evasiveStance, ""]}]
  tankStance:Set[${DetrUI.FindSetting[tankStance, ""]}]
  burnStance:Set[${DetrUI.FindSetting[burnStance, ""]}]
  canniStance:Set[${DetrUI.FindSetting[canniStance, ""]}]
  ;========== ITEMS TAB
  doItemSelfBuff:Set[${BeneUI.FindSetting[doItemSelfBuff, FALSE]}]
  doItemCanni:Set[${BeneUI.FindSetting[doItemCanni, FALSE]}]
  doItemTank:Set[${BeneUI.FindSetting[doItemTank, FALSE]}]
  doItemAssist:Set[${BeneUI.FindSetting[doItemAssist, FALSE]}]
  doItemOTgt:Set[${BeneUI.FindSetting[doItemOTgt, FALSE]}]
  doRedBerries:Set[${BeneUI.FindSetting[doRedBerries, TRUE]}]
  doBlueBerries:Set[${BeneUI.FindSetting[doBlueBerries, TRUE]}]
  doGreenBerries:Set[${BeneUI.FindSetting[doGreenBerries, TRUE]}]
  useRedBerryPct:Set[${BeneUI.FindSetting[useRedBerryPct, 80]}]
  useBlueBerryPct:Set[${BeneUI.FindSetting[useBlueBerryPct, 80]}]
  doWS:Set[${BeneUI.FindSetting[doWS, FALSE]}]
  ;###################
  ;########## CLASS TAB
  ;###################
  ;========== SONG TAB
  doCombatSong:Set[${ClassUI.FindSetting[doCombatSong, FALSE]}]
  doNonCombatSong:Set[${ClassUI.FindSetting[doNonCombatSong, FALSE]}]
  doMoveSong:Set[${ClassUI.FindSetting[doMoveSong, FALSE]}]
  combatSong:Set[${ClassUI.FindSetting[combatSong, ""]}]
  nonCombatSong:Set[${ClassUI.FindSetting[nonCombatSong, ""]}]
  moveSong:Set[${ClassUI.FindSetting[moveSong, ""]}]
  ;========== PET TAB
  doPet:Set[${PetUI.FindSetting[doPet, FALSE]}]
  doPetInCombat:Set[${PetUI.FindSetting[doPetInCombat, FALSE]}]
  doMinion:Set[${PetUI.FindSetting[doMinion, FALSE]}]
  doMinionInCombat:Set[${PetUI.FindSetting[doMinionInCombat, FALSE]}]
  doPetHeal:Set[${PetUI.FindSetting[doPetHeal, FALSE]}]
  doPetHOT:Set[${PetUI.FindSetting[doPetHOT, FALSE]}]
  healPetPct:Set[${PetUI.FindSetting[healPetPct, 30]}]
  healPetHOTPct:Set[${PetUI.FindSetting[healPetHOTPct, 60]}]
  summonPet:Set[${PetUI.FindSetting[summonPet, ""]}]
  summonMinion:Set[${PetUI.FindSetting[summonMinion, ""]}]
  numMinionsToSummon:Set[${PetUI.FindSetting[numMinionsToSummon]}]
  ;========== TGTBUFFS TAB
  doStancePush:Set[${ClassUI.FindSetting[doStancePush, FALSE]}]
  stancePush:Set[${ClassUI.FindSetting[stancePush, ""]}]
  doStripEnchantment:Set[${ClassUI.FindSetting[doStripEnchantment, FALSE]}]
  stripEnchantment:Set[${ClassUI.FindSetting[stripEnchantment, ""]}]
  ;========== SPECIAL POINTS TAB
  doSpecPts:Set[${ClassUI.FindSetting[doSpecPts, FALSE]}]
  minSpecPts:Set[${ClassUI.FindSetting[minSpecPts, 0]}]
  doSpecPtsStance:Set[${ClassUI.FindSetting[doSpecPtsStance, FALSE]}]
  doSpecPtsBurn:Set[${ClassUI.FindSetting[doSpecPtsBurn, FALSE]}]
  minSpecPtsBurn:Set[${ClassUI.FindSetting[minSpecPtsBurn, 0]}]
  specPtsStance:Set[${ClassUI.FindSetting[specPtsStance]}]
  ;========== HATE MANAGEMENT TAB
  doHateToTank:Set[${ClassUI.FindSetting[doHateToTank, FALSE]}]
  doAEHateToTank:Set[${ClassUI.FindSetting[doAEHateToTank, FALSE]}]
  hateToTankPct:Set[${ClassUI.FindSetting[hateToTankPct, 100]}]
  doDTgtDeaggro:Set[${ClassUI.FindSetting[doDTgtDeaggro, FALSE]}]
  DTgtDeaggro:Set[${ClassUI.FindSetting[DTgtDeaggro]}]
  doHateOnAdds:Set[${ClassUI.FindSetting[doHateOnAdds, FALSE]}]
  ;###################
  ;########## HUNT TAB
  ;###################
  doPull:Set[${HuntUI.FindSetting[doPull, FALSE]}]
  doPullNPC:Set[${HuntUI.FindSetting[doPullNPC, FALSE]}]
  doResources:Set[${HuntUI.FindSetting[doResources , FALSE]}]
  doAvoidAggro:Set[${HuntUI.FindSetting[doAvoidAggro, FALSE]}]
  doPiggyBack:Set[${HuntUI.FindSetting[doPiggyBack, FALSE]}]
  doScanWhileMove:Set[${HuntUI.FindSetting[doScanWhileMove, FALSE]}]
  pullDist:Set[${HuntUI.FindSetting[pullDist, 14]}]
  piggyWPDist:Set[${HuntUI.FindSetting[piggyWPDist, 0]}]
  scanWPDist:Set[${HuntUI.FindSetting[scanWPDist, 0]}]
  minLvlPull:Set[${HuntUI.FindSetting[minLvlPull, 0]}]
  maxLvlPull:Set[${HuntUI.FindSetting[maxLvlPull, 100]}]
  huntWP[1]:Set[${HuntUI.FindSetting[huntWP1X, 0]}, ${HuntUI.FindSetting[huntWP1Y, 0]}]
  huntWP[2]:Set[${HuntUI.FindSetting[huntWP2X, 0]}, ${HuntUI.FindSetting[huntWP2Y, 0]}]
  huntWP[3]:Set[${HuntUI.FindSetting[huntWP3X, 0]}, ${HuntUI.FindSetting[huntWP3Y, 0]}]
  huntWP[4]:Set[${HuntUI.FindSetting[huntWP4X, 0]}, ${HuntUI.FindSetting[huntWP4Y, 0]}]
  huntWP[5]:Set[${HuntUI.FindSetting[huntWP5X, 0]}, ${HuntUI.FindSetting[huntWP5Y, 0]}]
  huntWP[6]:Set[${HuntUI.FindSetting[huntWP6X, 0]}, ${HuntUI.FindSetting[huntWP6Y, 0]}]
  huntWP[7]:Set[${HuntUI.FindSetting[huntWP7X, 0]}, ${HuntUI.FindSetting[huntWP7Y, 0]}]
  huntWP[8]:Set[${HuntUI.FindSetting[huntWP8X, 0]}, ${HuntUI.FindSetting[huntWP8Y, 0]}]
  huntWP[9]:Set[${HuntUI.FindSetting[huntWP9X, 0]}, ${HuntUI.FindSetting[huntWP9Y, 0]}]
  huntWP[10]:Set[${HuntUI.FindSetting[huntWP10X, 0]}, ${HuntUI.FindSetting[huntWP10Y, 0]}]
  huntDist[1]:Set[${HuntUI.FindSetting[huntDist1, 0]}]
  huntDist[2]:Set[${HuntUI.FindSetting[huntDist2, 0]}]
  huntDist[3]:Set[${HuntUI.FindSetting[huntDist3, 0]}]
  huntDist[4]:Set[${HuntUI.FindSetting[huntDist4, 0]}]
  huntDist[5]:Set[${HuntUI.FindSetting[huntDist5, 0]}]
  huntDist[6]:Set[${HuntUI.FindSetting[huntDist6, 0]}]
  huntDist[7]:Set[${HuntUI.FindSetting[huntDist7, 0]}]
  huntDist[8]:Set[${HuntUI.FindSetting[huntDist8, 0]}]
  huntDist[9]:Set[${HuntUI.FindSetting[huntDist9, 0]}]
  huntDist[10]:Set[${HuntUI.FindSetting[huntDist10, 0]}]
  huntWPPause[1]:Set[${HuntUI.FindSetting[huntWPPause1, 0.00]}]
  huntWPPause[2]:Set[${HuntUI.FindSetting[huntWPPause2, 0.00]}]
  huntWPPause[3]:Set[${HuntUI.FindSetting[huntWPPause3, 0.00]}]
  huntWPPause[4]:Set[${HuntUI.FindSetting[huntWPPause4, 0.00]}]
  huntWPPause[5]:Set[${HuntUI.FindSetting[huntWPPause5, 0.00]}]
  huntWPPause[6]:Set[${HuntUI.FindSetting[huntWPPause6, 0.00]}]
  huntWPPause[7]:Set[${HuntUI.FindSetting[huntWPPause7, 0.00]}]
  huntWPPause[8]:Set[${HuntUI.FindSetting[huntWPPause8, 0.00]}]
  huntWPPause[9]:Set[${HuntUI.FindSetting[huntWPPause9, 0.00]}]
  huntWPPause[10]:Set[${HuntUI.FindSetting[huntWPPause10, 0.00]}]
  ;###################
  ;########## ABILITY ROTATIONS
  ;###################
  meleeDebuffRot:Set[${LavishSettings[ezvg].FindSet[meleeDebuffRot]}]
  meleeRot:Set[${LavishSettings[ezvg].FindSet[meleeRot]}]
  meleeDotRot:Set[${LavishSettings[ezvg].FindSet[meleeDotRot]}]
  rangeDebuffRot:Set[${LavishSettings[ezvg].FindSet[rangeDebuffRot]}]
  rangeRot:Set[${LavishSettings[ezvg].FindSet[rangeRot]}]
  rangeDotRot:Set[${LavishSettings[ezvg].FindSet[rangeDotRot]}]
  reactRot:Set[${LavishSettings[ezvg].FindSet[reactRot]}]
  debuffRot:Set[${LavishSettings[ezvg].FindSet[debuffRot]}]
  dotRot:Set[${LavishSettings[ezvg].FindSet[dotRot]}]
  nukeRot:Set[${LavishSettings[ezvg].FindSet[nukeRot]}]
  AERot:Set[${LavishSettings[ezvg].FindSet[AERot]}]
  pullRot:Set[${LavishSettings[ezvg].FindSet[pullRot]}]
  noGCDList:Set[${LavishSettings[ezvg].FindSet[noGCDList]}]
  healBigRot:Set[${LavishSettings[ezvg].FindSet[healBigRot]}]
  healMedRot:Set[${LavishSettings[ezvg].FindSet[healMedRot]}]
  healEmgRot:Set[${LavishSettings[ezvg].FindSet[healEmgRot]}]
  healGrpRot:Set[${LavishSettings[ezvg].FindSet[healGrpRot]}]
  healHotRot:Set[${LavishSettings[ezvg].FindSet[healHotRot]}]
  buffRot:Set[${LavishSettings[ezvg].FindSet[buffRot]}]
  combatBuffRot:Set[${LavishSettings[ezvg].FindSet[combatBuffRot]}]
  groupBuffRot:Set[${LavishSettings[ezvg].FindSet[groupBuffRot]}]
  canniRot:Set[${LavishSettings[ezvg].FindSet[canniRot]}]
  burnBuffRot:Set[${LavishSettings[ezvg].FindSet[burnBuffRot]}]
  burnRot:Set[${LavishSettings[ezvg].FindSet[burnRot]}]
  evasiveRot:Set[${LavishSettings[ezvg].FindSet[evasiveRot]}]
  rescueRot:Set[${LavishSettings[ezvg].FindSet[rescueRot]}]
  specPtsRot:Set[${LavishSettings[ezvg].FindSet[specPtsRot]}]
  itemBuffRot:Set[${LavishSettings[ezvg].FindSet[itemBuffRot]}]
  burnItemBuffRot:Set[${LavishSettings[ezvg].FindSet[burnItemBuffRot]}]
  burnConsumableItemBuffRot:Set[${LavishSettings[ezvg].FindSet[burnConsumableItemBuffRot]}]
  invTrash:Set[${LavishSettings[ItemsDict].FindSet[invTrash]}]
  lootOnly:Set[${LavishSettings[ItemsDict].FindSet[lootOnly]}]
  itemTankRot:Set[${LavishSettings[ezvg].FindSet[itemTankRot]}]
  itemAssistRot:Set[${LavishSettings[ezvg].FindSet[itemAssistRot]}]
  itemOTgtRot:Set[${LavishSettings[ezvg].FindSet[itemOTgtRot]}]
  itemCanniRot:Set[${LavishSettings[ezvg].FindSet[itemCanniRot]}]
  hateToTankRot:Set[${LavishSettings[ezvg].FindSet[hateToTankRot]}]
  AEHateToTankRot:Set[${LavishSettings[ezvg].FindSet[AEHateToTankRot]}]
  DTgtDeaggroRot:Set[${LavishSettings[ezvg].FindSet[DTgtDeaggroRot]}]
}

function xmlSave()
{
	echo --- xmlSave --- saving settings
  ;###################
  ;########## MAIN TAB
  ;###################
  MainUI:AddSetting[Assist, ${Assist}]
  MainUI:AddSetting[Tank, ${Tank}]
  MainUI:AddSetting[Position, ${Position}]
  MainUI:AddSetting[FollowT, ${FollowT}]
  MainUI:AddSetting[doAssist, ${doAssist}]
  MainUI:AddSetting[doDeleteTrash, ${doDeleteTrash}]
  MainUI:AddSetting[doHeal, ${doHeal}]
  MainUI:AddSetting[doFace, ${doFace}]
  MainUI:AddSetting[doLoot, ${doLoot}]
  MainUI:AddSetting[doLootOnly, ${doLootOnly}]
  MainUI:AddSetting[scanLootRng, ${scanLootRng}]
  MainUI:AddSetting[doHarvest, ${doHarvest}]
  MainUI:AddSetting[doIgnoreFurious, ${doIgnoreFurious}]
  MainUI:AddSetting[doFollow, ${doFollow}]
  MainUI:AddSetting[doPositionFront, ${doPositionFront}]
  MainUI:AddSetting[doPositionSide, ${doPositionSide}]
  MainUI:AddSetting[doPositionBack, ${doPositionBack}]
  FolUI:AddSetting[doMoveToTarget, ${doMoveToTarget}]
  FolUI:AddSetting[doCombatFollow, ${doCombatFollow}]
  FolUI:AddSetting[FollowDist, ${FollowDist}]
  FolUI:AddSetting[combatFollowDist, ${combatFollowDist}]
  FolUI:AddSetting[moveToTargetDist, ${moveToTargetDist}]
  ;###################
  ;########## OPTIONS TAB
  ;###################
  ;========== DETR TAB
  DetrUI:AddSetting[doMeleeDebuff, ${doMeleeDebuff}]
  DetrUI:AddSetting[doMelee, ${doMelee}]
  DetrUI:AddSetting[doMeleeDots, ${doMeleeDots}]
  DetrUI:AddSetting[doRangeDebuff, ${doRangeDebuff}]
  DetrUI:AddSetting[doRange, ${doRange}]
  DetrUI:AddSetting[doRangeDots, ${doRangeDots}]
  DetrUI:AddSetting[doDebuff, ${doDebuff}]
  DetrUI:AddSetting[doNuke, ${doNuke}]
  DetrUI:AddSetting[doDots, ${doDots}]
  DetrUI:AddSetting[doReact, ${doReact}]
  DetrUI:AddSetting[doKillingBlow, ${doKillingBlow}]
  DetrUI:AddSetting[doAE, ${doAE}]
  DetrUI:AddSetting[AEDist, ${AEDist}]
  DetrUI:AddSetting[doEvasive, ${doEvasive}]
  DetrUI:AddSetting[doRescue, ${doRescue}]
  DetrUI:AddSetting[EngagePct, ${EngagePct}]
  DetrUI:AddSetting[evasivePct, ${evasivePct}]
  DetrUI:AddSetting[enerNukePct, ${enerNukePct}]
  DetrUI:AddSetting[enerDOTPct, ${enerDOTPct}]
  DetrUI:AddSetting[killingBlowPct, ${killingBlowPct}]
  DetrUI:AddSetting[killingBlow , ${killingBlow}]
  ;========== HEAL TAB
  BeneUI:AddSetting[doHOT, ${doHOT}]
  BeneUI:AddSetting[doRez, ${doRez}]
  BeneUI:AddSetting[doCmbtRez, ${doCmbtRez}]
  BeneUI:AddSetting[doGroupHeal, ${doGroupHeal}]
  BeneUI:AddSetting[healGrpMinInRng, ${healGrpMinInRng}]
  BeneUI:AddSetting[healBigPct, ${healBigPct}]
  BeneUI:AddSetting[healMedPct, ${healMedPct}]
  BeneUI:AddSetting[healEmgPct, ${healEmgPct}]
  BeneUI:AddSetting[healHOTPct, ${healHOTPct}]
  BeneUI:AddSetting[healGrpPct, ${healGrpPct}]
  BeneUI:AddSetting[combatRez, ${combatRez}]
  BeneUI:AddSetting[nonCombatRez, ${nonCombatRez}]
  BeneUI:AddSetting[rezStone, ${rezStone}]
  ;========== BENE TAB
  BeneUI:AddSetting[doCanni, ${doCanni}]
  BeneUI:AddSetting[doSelfBuff, ${doSelfBuff}]
  BeneUI:AddSetting[doCombatBuff, ${doCombatBuff}]
  BeneUI:AddSetting[doGroupBuff, ${doGroupBuff}]
  BeneUI:AddSetting[canniEnerPct, ${canniEnerPct}]
  BeneUI:AddSetting[canniHPPct, ${canniHPPct}]
  ;========== BURN TAB
  DetrUI:AddSetting[doBurn, ${doBurn}]
  DetrUI:AddSetting[doBurnItemBuff, ${doBurnItemBuff}]
  DetrUI:AddSetting[doBurnConsumableItemBuff, ${doBurnConsumableItemBuff}]
  DetrUI:AddSetting[burnPct, ${burnPct}]
  DetrUI:AddSetting[burnAbovePct, ${burnAbovePct}]
  DetrUI:AddSetting[burnTrigger, ${burnTrigger}]
  DetrUI:AddSetting[burnBuffTrigger, ${burnBuffTrigger}]
  DetrUI:AddSetting[doBurnAbil, ${doBurnAbil}]
  DetrUI:AddSetting[doBurnBuff, ${doBurnBuff}]
  DetrUI:AddSetting[doBurnBuffExists, ${doBurnBuffExists}]
  DetrUI:AddSetting[burnBuffExistsTrigger, ${burnBuffExistsTrigger}]
  DetrUI:AddSetting[doBurnEpic, ${doBurnEpic}]
  DetrUI:AddSetting[burnEpicName, ${burnEpicName}]
  DetrUI:AddSetting[epicSlot, ${epicSlot}]
  ;========== STANCE TAB
  DetrUI:AddSetting[doMeleeStance, ${doMeleeStance}]
  DetrUI:AddSetting[doSpellStance, ${doSpellStance}]
  DetrUI:AddSetting[doHealStance, ${doHealStance}]
  DetrUI:AddSetting[doEvasiveStance, ${doEvasiveStance}]
  DetrUI:AddSetting[doTankStance, ${doTankStance}]
  DetrUI:AddSetting[doBurnStance, ${doBurnStance}]
  DetrUI:AddSetting[doCanniStance, ${doCanniStance}]
  DetrUI:AddSetting[meleeStance, ${meleeStance}]
  DetrUI:AddSetting[spellStance, ${spellStance}]
  DetrUI:AddSetting[healStance, ${healStance}]
  DetrUI:AddSetting[evasiveStance, ${evasiveStance}]
  DetrUI:AddSetting[tankStance, ${tankStance}]
  DetrUI:AddSetting[burnStance, ${burnStance}]
  DetrUI:AddSetting[canniStance, ${canniStance}]
  ;========== ITEMS TAB
  BeneUI:AddSetting[doItemSelfBuff, ${doItemSelfBuff}]
  BeneUI:AddSetting[doItemCanni, ${doItemCanni}]
  BeneUI:AddSetting[doItemTank, ${doItemTank}]
  BeneUI:AddSetting[doItemAssist, ${doItemAssist}]
  BeneUI:AddSetting[doItemOTgt, ${doItemOTgt}]
  BeneUI:AddSetting[doRedBerries, ${doRedBerries}]
  BeneUI:AddSetting[doBlueBerries, ${doBlueBerries}]]
  BeneUI:AddSetting[doGreenBerries, ${doGreenBerries}]
  BeneUI:AddSetting[useRedBerryPct, ${useRedBerryPct}]
  BeneUI:AddSetting[useRedBerryPct, ${useBlueBerryPct}]
  BeneUI:AddSetting[doWS, ${doWS}]
  ;###################
  ;########## CLASS TAB
  ;###################
  ;========== SONG TAB
  ClassUI:AddSetting[doCombatSong, ${doCombatSong}]
  ClassUI:AddSetting[doNonCombatSong, ${doNonCombatSong}]
  ClassUI:AddSetting[doMoveSong, ${doMoveSong}]
  ClassUI:AddSetting[combatSong, ${combatSong}]
  ClassUI:AddSetting[nonCombatSong, ${nonCombatSong}]
  ClassUI:AddSetting[moveSong, ${moveSong}]
  ;========== PET TAB
  PetUI:AddSetting[doPet, ${doPet}]
  PetUI:AddSetting[doPetInCombat, ${doPetInCombat}]
  PetUI:AddSetting[doMinion, ${doMinion}]
  PetUI:AddSetting[doMinionInCombat, ${doMinionInCombat}]
  PetUI:AddSetting[doPetHeal, ${doPetHeal}]
  PetUI:AddSetting[doPetHOT, ${doPetHOT}]
  PetUI:AddSetting[healPetPct, ${healPetPct}]
  PetUI:AddSetting[healPetHOTPct, ${healPetHOTPct}]
  PetUI:AddSetting[summonPet, ${summonPet}]
  PetUI:AddSetting[summonMinion, ${summonMinion}]
  PetUI:AddSetting[numMinionsToSummon, ${numMinionsToSummon}]
  ;========== TGTBUFFS TAB
  ClassUI:AddSetting[doStancePush, ${doStancePush}]
  ClassUI:AddSetting[stancePush, ${stancePush}]
  ClassUI:AddSetting[doStripEnchantment, ${doStripEnchantment}]
  ClassUI:AddSetting[stripEnchantment, ${stripEnchantment}]
  ;========== SPECIAL POINTS TAB
  ClassUI:AddSetting[doSpecPts, ${doSpecPts}]
  ClassUI:AddSetting[minSpecPts, ${minSpecPts}]
  ClassUI:AddSetting[doSpecPtsStance, ${doSpecPtsStance}]
  ClassUI:AddSetting[doSpecPtsBurn, ${doSpecPtsBurn}]
  ClassUI:AddSetting[minSpecPtsBurn, ${minSpecPtsBurn}]
  ClassUI:AddSetting[specPtsStance, ${specPtsStance}]
  ;========== HATE MANAGEMENT TAB
  ClassUI:AddSetting[doHateToTank, ${doHateToTank}]
  ClassUI:AddSetting[doAEHateToTank, ${doAEHateToTank}]
  ClassUI:AddSetting[hateToTankPct, ${hateToTankPct}]
  ClassUI:AddSetting[doDTgtDeaggro, ${doDTgtDeaggro}]
  ClassUI:AddSetting[DTgtDeaggro, ${DTgtDeaggro}]
  ClassUI:AddSetting[doHateOnAdds, ${doHateOnAdds}]
  ;###################
  ;########## HUNT TAB
  ;###################
  ;========== HUNT TAB
  HuntUI:AddSetting[doPull, ${doPull}]
  HuntUI:AddSetting[doPullNPC, ${doPullNPC}]
  HuntUI:AddSetting[doResources, ${doResources}]
  HuntUI:AddSetting[doAvoidAggro, ${doAvoidAggro}]
  HuntUI:AddSetting[doPiggyBack, ${doPiggyBack}]
  HuntUI:AddSetting[doScanWhileMove, ${doScanWhileMove}]
  HuntUI:AddSetting[pullDist, ${pullDist}]
  HuntUI:AddSetting[piggyWPDist, ${piggyWPDist}]
  HuntUI:AddSetting[scanWPDist, ${scanWPDist}]
  HuntUI:AddSetting[minLvlPull, ${minLvlPull}]
  HuntUI:AddSetting[maxLvlPull, ${maxLvlPull}]
  HuntUI:AddSetting[huntWP1X, ${huntWP[1].X}]
  HuntUI:AddSetting[huntWP2X, ${huntWP[2].X}]
  HuntUI:AddSetting[huntWP3X, ${huntWP[3].X}]
  HuntUI:AddSetting[huntWP4X, ${huntWP[4].X}]
  HuntUI:AddSetting[huntWP5X, ${huntWP[5].X}]
  HuntUI:AddSetting[huntWP6X, ${huntWP[6].X}]
  HuntUI:AddSetting[huntWP7X, ${huntWP[7].X}]
  HuntUI:AddSetting[huntWP8X, ${huntWP[8].X}]
  HuntUI:AddSetting[huntWP9X, ${huntWP[9].X}]
  HuntUI:AddSetting[huntWP10X, ${huntWP[10].X}]
  HuntUI:AddSetting[huntWP1Y, ${huntWP[1].Y}]
  HuntUI:AddSetting[huntWP2Y, ${huntWP[2].Y}]
  HuntUI:AddSetting[huntWP3Y, ${huntWP[3].Y}]
  HuntUI:AddSetting[huntWP4Y, ${huntWP[4].Y}]
  HuntUI:AddSetting[huntWP5Y, ${huntWP[5].Y}]
  HuntUI:AddSetting[huntWP6Y, ${huntWP[6].Y}]
  HuntUI:AddSetting[huntWP7Y, ${huntWP[7].Y}]
  HuntUI:AddSetting[huntWP8Y, ${huntWP[8].Y}]
  HuntUI:AddSetting[huntWP9Y, ${huntWP[9].Y}]
  HuntUI:AddSetting[huntWP10Y, ${huntWP[10].Y}]
  HuntUI:AddSetting[huntDist1, ${huntDist[1]}]
  HuntUI:AddSetting[huntDist2, ${huntDist[2]}]
  HuntUI:AddSetting[huntDist3, ${huntDist[3]}]
  HuntUI:AddSetting[huntDist4, ${huntDist[4]}]
  HuntUI:AddSetting[huntDist5, ${huntDist[5]}]
  HuntUI:AddSetting[huntDist6, ${huntDist[6]}]
  HuntUI:AddSetting[huntDist7, ${huntDist[7]}]
  HuntUI:AddSetting[huntDist8, ${huntDist[8]}]
  HuntUI:AddSetting[huntDist9, ${huntDist[9]}]
  HuntUI:AddSetting[huntDist10, ${huntDist[10]}]
  HuntUI:AddSetting[huntWPPause1, ${huntWPPause[1]}]
  HuntUI:AddSetting[huntWPPause2, ${huntWPPause[2]}]
  HuntUI:AddSetting[huntWPPause3, ${huntWPPause[3]}]
  HuntUI:AddSetting[huntWPPause4, ${huntWPPause[4]}]
  HuntUI:AddSetting[huntWPPause5, ${huntWPPause[5]}]
  HuntUI:AddSetting[huntWPPause6, ${huntWPPause[6]}]
  HuntUI:AddSetting[huntWPPause7, ${huntWPPause[7]}]
  HuntUI:AddSetting[huntWPPause8, ${huntWPPause[8]}]
  HuntUI:AddSetting[huntWPPause9, ${huntWPPause[9]}]
  HuntUI:AddSetting[huntWPPause10, ${huntWPPause[10]}]

  LavishSettings[ezvg]:Export[${LavishScript.CurrentDirectory}/Scripts/ezvg/UI/${Me.FName}.xml]
  
  LavishSettings[AbilDict]:Export[${LavishScript.CurrentDirectory}/Scripts/ezvg/LIBRARY/abilities.xml]
  LavishSettings[MobDict]:Export[${LavishScript.CurrentDirectory}/Scripts/ezvg/LIBRARY/mobs.xml]
  LavishSettings[EffectDict]:Export[${LavishScript.CurrentDirectory}/Scripts/ezvg/LIBRARY/effects.xml]
  LavishSettings[ItemsDict]:Export[${LavishScript.CurrentDirectory}/Scripts/ezvg/LIBRARY/items.xml]

}
